/*
 * @Author: Trae AI
 * @Date: 2024-07-15
 * @Description: 办事指南服务
 */
import { Inject, Injectable } from '@nestjs/common';
import {
  AddSysGuideDto,
  GetSysGuideListDto,
  UpdateSysGuideDto,
  GetEnabledGuideListDto,
} from './dto/req-sys-guide.dto';
import { CustomPrismaService, PrismaService } from 'nestjs-prisma';
import { ExtendedPrismaClient } from 'src/shared/prisma/prisma.extension';
import { ApiException } from 'src/common/exceptions/api.exception';
import { ImportSysGuideDto } from './dto/import-sys-guide.dto';
import dayjs from 'dayjs';
import { Console } from 'console';

@Injectable()
export class SysGuideService {
  constructor(
    private readonly prisma: PrismaService,
    @Inject('CustomPrisma')
    private readonly customPrisma: CustomPrismaService<ExtendedPrismaClient>,
  ) { }

  /* 分页查询 */
  async list(getSysGuideListDto: GetSysGuideListDto) {
    const { primaryGrid, secondaryGrid, gridAttributes, areaName, stockPrompt, pageNum, pageSize, areaId } = getSysGuideListDto;
    // where:{
    //   title: {
    //     contains: title,
    //   },
    //   createBy: {
    //     contains: createBy,
    //   },
    //   status,
    //   areaId,
    // }

    // 构建基本查询条件
    const whereCondition: any = {
      primaryGrid,
      secondaryGrid,
      gridAttributes,
      areaName,
      areaId,
      stockPrompt
    };
    // console.log('查询条件:', whereCondition); // 添加日志

    // 如果指定了地区ID，查询该地区及其所有子地区的数据
    if (areaId) {
      // 先查询指定地区的信息
      const area = await this.prisma.sysArea.findUnique({
        where: { areaId },
        select: { areaId: true, status: true }
      });

      if (area) {
        // 如果地区处于停用状态，则不查询该地区及其子地区的数据
        if (area.status === '1') {
          // 地区停用，返回空数组
          whereCondition.areaId = -1; // 使用一个不存在的ID确保查询结果为空
        } else {
          // 查询所有子地区（只包含启用状态的子地区）
          const childAreas = await this.prisma.sysArea.findMany({
            where: {
              ancestors: { contains: `,${areaId},` },
              delFlag: '0',
              status: '0'
            },
            select: { areaId: true }
          });

          // 构建包含所有相关地区ID的查询条件
          const areaIds = [areaId, ...childAreas.map(item => item.areaId)];
          whereCondition.areaId = { in: areaIds };
        }
      } else {
        // 如果地区不存在，仍然使用原始的areaId查询
        whereCondition.areaId = areaId;
      }
    } else {
      // 如果未指定地区ID，只查询启用状态的地区下的指南
      const enabledAreas = await this.prisma.sysArea.findMany({
        where: {
          status: '0',
          delFlag: '0'
        },
        select: { areaId: true }
      });

      // 如果有启用的地区，则只查询这些地区的指南
      if (enabledAreas.length > 0) {
        const areaIds = enabledAreas.map(item => item.areaId);
        whereCondition.areaId = { in: areaIds };
      }
    }

    // 确保分页参数有效，设置默认值
    const validPageNum = pageNum && pageNum > 0 ? pageNum : 1;
    const validPageSize = pageSize && pageSize > 0 ? pageSize : 10;

    const { total, rows } = await this.customPrisma.client.sysGuide.findAndCount({
      where: whereCondition,
      // where: {
      //   secondaryGrid,
      //   delFlag: '0',
      // },
      orderBy: [
        {
          createTime: 'desc',
        },
      ],
      // include: {
      //   area: {
      //     select: {
      //       areaId: true,
      //       areaName: true,
      //     },
      //   },
      // },
      skip: (validPageNum - 1) * validPageSize,
      take: validPageSize,
    });
    const newrows = rows.map((item) => {
      return Object.assign({}, item);
      // return Object.assign({}, item, {
      //   content: item.content ? item.content.toString() : '',
      //   areaName: item.area ? item.area.areaName : '',
      // });
    });
    return { total, rows: newrows };
  }

  /* 新增 */
  async add(addSysGuideDto: AddSysGuideDto) {
    const data = Object.assign({}, addSysGuideDto, {
      content: Buffer.from(addSysGuideDto.content || '', 'utf8'),
    });
    return await this.prisma.sysGuide.create({
      data,
    });
  }

  /* 通过id查询 */
  async oneByGuideId(guideId: number) {
    const guide = await this.prisma.sysGuide.findUnique({
      where: {
        guideId,
      },
    });
    return Object.assign({}, guide, {
      content: guide.content ? guide.content.toString() : '',
    });
  }

  /* 更新 */
  async update(updateSysGuideDto: UpdateSysGuideDto) {
    return await this.prisma.$transaction(async (prisma) => {
      const { guideId, areaId } = updateSysGuideDto;
      const guide = await prisma.sysGuide.findUnique({
        where: {
          guideId,
        },
      });
      if (!guide) throw new ApiException('该记录不存在，请重新查询后操作。');

      if (areaId) {
        const area = await prisma.sysArea.findFirst({
          where: {
            areaId,
            delFlag: '0'
          }
        });
        if (area) {
          updateSysGuideDto.areaName = area.areaName;
        }
      }

      // 直接使用DTO对象进行更新，而不是动态构建updateData
      const updateData = { ...updateSysGuideDto };
      delete updateData.guideId; // 删除guideId，因为它是where条件，不是要更新的字段

      // 特殊处理content字段
      if (updateData.content !== undefined) {
        updateData.content = Buffer.from(updateData.content || '', 'utf8');
      }

      return await prisma.sysGuide.update({
        data: updateData,
        where: {
          guideId,
        },
      });
    });
  }

  /* 获取第一条办事指南数据 */
  async getFirstGuide() {
    const guide = await this.prisma.sysGuide.findFirst({
      where: {
        status: '0', // 0表示启用
      },
      orderBy: [
        { weight: 'asc' },
        { updateTime: 'desc' },
        { createTime: 'desc' }
      ]
    });
    return guide ? Object.assign({}, guide, {
      content: guide.content ? guide.content.toString() : ''
    }) : null;
  }

  /* 删除指南 */
  async delete(guideIdArr: number[]) {
    await this.prisma.sysGuide.deleteMany({
      where: {
        guideId: {
          in: guideIdArr,
        },
      },
    });
  }

  /* 获取启用的指南列表（小程序端使用） */
  async enabledList(getEnabledGuideListDto: GetEnabledGuideListDto) {
    const { secondaryGrid, pageNum, pageSize, areaId } = getEnabledGuideListDto;

    // 构建基本查询条件
    const whereCondition: any = {
      status: '0', // 0表示启用
    };

    // 只有当secondaryGrid有值时才添加contains条件
    if (secondaryGrid) {
      whereCondition.secondaryGrid = {
        contains: secondaryGrid,
      };
    }

    // 如果指定了地区ID，查询该地区及其所有子地区的数据
    if (areaId) {
      // 先查询指定地区的信息
      const area = await this.prisma.sysArea.findUnique({
        where: { areaId },
        select: { areaId: true, ancestors: true, status: true }
      });

      if (area) {
        // 如果地区处于停用状态，则不查询该地区及其子地区的数据
        if (area.status === '1') {
          // 地区停用，返回空.数组
          whereCondition.areaId = -1; // 使用一个不存在的ID确保查询结果为空
        } else {
          // 查询所有子地区（只包含启用状态的子地区）
          const childAreas = await this.prisma.sysArea.findMany({
            where: {
              ancestors: { contains: `,${areaId},` },
              delFlag: '0',
              status: '0'
            },
            select: { areaId: true }
          });

          // 构建包含所有相关地区ID的查询条件
          const areaIds = [areaId, ...childAreas.map(item => item.areaId)];
          whereCondition.areaId = { in: areaIds };
        }
      } else {
        // 如果地区不存在，仍然使用原始的areaId查询
        whereCondition.areaId = areaId;
      }
    } else {
      // 如果未指定地区ID，只查询启用状态的地区下的指南
      const enabledAreas = await this.prisma.sysArea.findMany({
        where: {
          status: '0',
          delFlag: '0'
        },
        select: { areaId: true }
      });

      // 如果有启用的地区，则只查询这些地区的指南
      if (enabledAreas.length > 0) {
        const areaIds = enabledAreas.map(item => item.areaId);
        whereCondition.areaId = { in: areaIds };
      }
    }

    // 确保分页参数有效，设置默认值
    const validPageNum = pageNum && pageNum > 0 ? pageNum : 1;
    const validPageSize = pageSize && pageSize > 0 ? pageSize : 10;

    const { total, rows } = await this.customPrisma.client.sysGuide.findAndCount({
      where: whereCondition,
      orderBy: [
        {
          weight: 'asc',
        },
        {
          createTime: 'desc',
        },
      ],
      skip: (validPageNum - 1) * validPageSize,
      take: validPageSize,
    });

    const newrows = rows.map((item) => {
      return Object.assign({}, item, {
        content: item.content ? item.content.toString() : '',
      });
    });
    return { total, rows: newrows };
  }

  /* 导入指南列表 */
  async importData(importSysGuideDtoArr: ImportSysGuideDto[], isUpdate: boolean) {
    console.log('导入数据:', importSysGuideDtoArr); // 添加日志

    // 添加成功和失败计数器
    let successCount = 0;
    let failCount = 0;

    return await this.prisma.$transaction(async (prisma) => {
      for (const item of importSysGuideDtoArr) {
        // 根据areaName查询对应的areaId
        let areaId = null;
        if (item.areaName) {
          const area = await prisma.sysArea.findFirst({
            where: {
              areaName: item.areaName,
              delFlag: '0',
              status: '0' // 0表示启用
            }
          });
          if (area) {
            areaId = area.areaId;
          }
        }

        // 构建基础数据
        const baseData = {
          primaryGrid: item.primaryGrid,
          secondaryGrid: item.secondaryGrid,
          gridAttributes: item.gridAttributes,
          licensedHouseholds: item.licensedHouseholds,
          numberHouseholds: item.numberHouseholds,
          preNumber: item.preNumber,
          difference: item.difference,
          stockPrompt: item.stockPrompt,
          content: item.content ? Buffer.from(item.content) : null,
          weight: item.weight || 99,
          status: item.status || '0',
          areaId: areaId,
          areaName: item.areaName,
          delFlag: '0',
          createTime: dayjs().toISOString(),
          createBy: 'admin' // 设置默认创建者
        };


        try {
          if (!isUpdate) {
            // 创建新记录
            // console.log('创建新记录:', baseData); // 添加日志
            await prisma.sysGuide.create({
              data: baseData
            });
            successCount++; // 成功计数器加1
          } else {
            // 更新现有记录
            const existingGuide = await prisma.sysGuide.findFirst({
              where: {
                secondaryGrid: item.secondaryGrid,
                delFlag: '0'
              }
            });

            if (existingGuide) {
              console.log('更新记录:', existingGuide.guideId); // 添加日志
              await prisma.sysGuide.update({
                where: {
                  guideId: existingGuide.guideId
                },
                data: {
                  ...baseData,
                  updateTime: dayjs().toISOString(),
                  updateBy: 'admin'
                }
              });
              successCount++; // 成功计数器加1
            } else {
              console.log('创建新记录(更新模式):', baseData); // 添加日志
              await prisma.sysGuide.create({
                data: baseData
              });
              successCount++; // 成功计数器加1
            }
          }
        } catch (error) {
          console.error('数据库操作错误:', error); // 添加错误日志
          failCount++; // 失败计数器加1
          // 不抛出异常，继续处理下一条记录
          console.error(`导入失败: ${error.message}`);
        }
      }

      // 返回成功和失败的统计信息
      return { successCount, failCount };
    });
  }
}